package com.asj.vivo.lock.service.command.specific;

import static com.asj.enums.DeviceIdentifierDictEnums.functionRestrict;
import static com.asj.enums.HttpRequestDictEnums.receiveResultUrl;
import static com.asj.enums.ResultCodeEnums.request_error;
import static com.asj.enums.ResultCodeEnums.result_error;
import static com.asj.enums.ResultCodeEnums.result_success;

import android.content.Context;
import android.util.Log;

import com.asj.annotation.AnnotationProcessor;
import com.asj.annotation.MethodRemark;
import com.asj.service.oppoSdk.OPPOSDKService;
import com.asj.utils.HttpRequestUtils;
import com.asj.utils.JSONParamPackingUtils;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

/**
 * 设备限制操作
 * */
public class SpecificFunctionRestrictService {

    /**
     * 操作中心，统一接收指令进行处理，然后调用指定方法
     * */
    public static void operatingCenter(JsonObject contentData, Context context){
        String resultMsg = "没有进行任何操作";
        try{
            JsonArray functionInfo = contentData.get(functionRestrict.getValue()).getAsJsonArray();
            if(functionInfo != null && !functionInfo.isEmpty()){
                //获取参数集合
                for (Object element : functionInfo) {
                    //从JsonArray中取出的还不是JsonObject,需要进行转换成为JsonObject
                    JsonObject jsonObject = JsonParser.parseString(element.toString()).getAsJsonObject();
                    if (jsonObject != null) {
                        // 现在您可以使用这个JSONObject对象
                        // 例如，访问它的键值对数据
                        String optionCode = jsonObject.get("optionCode").getAsString();
                        String optionParam = jsonObject.get("optionParamUseCharacters").getAsString();
                        Method method = AnnotationProcessor.executeAnnotatedMethods(OPPOSDKService.class, optionCode);
                        //没有的就跳过，别导致其他的无法执行
                        if(method == null){
                            //Http请求返回MDM中
                            continue;
                        }
                        MethodRemark remark = method.getAnnotation(MethodRemark.class);
                        if(remark == null){
                            continue;
                        }
                        //获取该方法的类型
                        int type = remark.type();

                        try {
                            OPPOSDKService OPPOSDKServiceInstance = new OPPOSDKService();
                            if(type == 1) {
                                //判断是否需要context参数
                                if(hasContextParameter(method)){
                                    method.invoke(OPPOSDKServiceInstance, optionParam,context);
                                }else{
                                    method.invoke(OPPOSDKServiceInstance, optionParam);
                                }
                            }
                            System.out.println(optionCode+"::"+method.getName() + "执行成功！");
                            // 没有异常抛出，方法执行成功
                            resultMsg = result_success.getMessage();
                        } catch (IllegalAccessException e) {
                            System.out.println("无法访问方法");
                            resultMsg = method.getName()+"无法访问方法";
                            break;
                        } catch (IllegalArgumentException e) {
                            System.out.println("方法参数不合法");
                            resultMsg = method.getName()+"方法参数不合法";
                            break;
                        } catch (InvocationTargetException e) {
                            System.out.println("被调用的方法内部抛出了异常");
                            resultMsg = method.getName()+"被调用的方法内部抛出了异常";
                            break;
                        } catch (Exception e) {
                            System.out.println("其他可能的异常");
                            resultMsg = method.getName()+"其他可能的异常";
                            break;
                        }
                    } else {
                        resultMsg = "Array contains an element that is not a JSONObject:"+ element;
                    }
                }
            }
            if(resultMsg.equals(result_success.getMessage())){
                JSONParamPackingUtils.functionPacking(contentData,result_success,null);
            }else{
                JSONParamPackingUtils.functionPacking(contentData,result_error,resultMsg);
            }
        }catch (Exception e){
            JSONParamPackingUtils.functionPacking(contentData,result_error,e.getMessage());
        }
        new Thread(()->{
            //将请求发送回去
            String result = HttpRequestUtils.retryHttpRequest(receiveResultUrl.getValue(), contentData.toString(), result_success.getCode(), 3,context);
            if(!result.equals(request_error.getMessage())){
                Log.w("功能限制情况告知成功！",result);
            }
        }).start();
    }

    /**
     * 是否需要context参数
     * */
    public static boolean hasContextParameter(Method method) {
        // 获取方法的所有参数
        Parameter[] parameters = method.getParameters();
        // 遍历参数
        for (Parameter parameter : parameters) {
            // 检查参数的类型是否是Context或者Context的子类
            if (parameter.getType() == Context.class) {
                return true;
            }
        }
        // 如果没有找到Context类型的参数，则返回false
        return false;
    }
}
